package view;

import dao.QiziDao;
import pojo.Chess;
import pojo.Player;
import service.GameService;
import utils.EmojiUtils;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Scanner;

public class GameView {
    public static Scanner scan = new Scanner(System.in);
    /*
    编号：1
    难度：简单
    负责人: Youndry
    功能: 欢迎界面
          接收用户输入：1.注册 2.登录
            输入1：进入注册页面 registerView()
            输入2：进入登录页面 loginView()
    参数: void
    返回值: void
 */
    public static void helloView(){
        // 界面内容
        System.out.println("==========欢迎来到轰天裂地五子棋==========");
        System.out.println("请输入你的选择: 1.注册 2.登录");
        // isValid:用来标记输入是否合法，合法则为true
        Boolean isValid = false;

        // choice:用来存储用户输入的选项
        int choice = 0;

        while (!isValid){
            // 检验用户输入的是否合法
            if (scan.hasNextInt()){
                choice = scan.nextInt();
                scan.nextLine();
            } else {
                System.out.println("输入有误，请输入一个整数");
                scan.nextLine();
                continue;
            }
            switch(choice) {
                case 1:
                    isValid = true;
                    registerView();
                    break;
                case 2:
                    isValid = true;
                    loginView();
                    break;
                default:
                    System.out.println("输入有误，请在给出的选项中选择");
            }
        }
    }

    /*
        编号：2
        难度：简单
        负责人: Youndry
        功能: 注册界面
            while(true) {
                接收用户输入：
                    创建的账号名(输入-1为返回欢迎界面)：
                判断用户输入是否为-1
                    是，返回欢迎界面 helloView(); return;
                    不是，判断账户是否存在在文件中(调用findPlayerService方法)
                        存在，提示用户该账号已存在
                        不存在，用户继续输入创建账号的密码 break;
            }
            while(true) {
                接收用户输入：
                    账号密码(输入-1为返回欢迎界面)：
                判断用户输入是否为-1
                    是，返回欢迎界面 helloView(); return;
                    不是，判断密码格式是否正确(长度为6-18位)
                        正确,调用register方法,调用loginView方法,break
                        不正确，提示用户密码格式错误
            }


        参数: void
        返回值: void

     */
    public static void registerView(){
        // 界面内容
        System.out.println("==========注册==========");
        // username:接收用户输入的账号
        // password:接收用户输入的密码
        String username;
        String password;

        System.out.println("请输入账号:");
        while(true) {
            // 接收用户输入的账号
            username = scan.nextLine();

            // 检测是否是-1（返回欢迎界面）
            if (username.equals("-1")) {
                helloView();
                return;
            }

            // 检验账号是否存在
            if (GameService.findPlayerService(username) != null) {
                System.out.println("该账号已存在，请重新输入");
                continue;
            }


            break;
        }

        System.out.println("请输入密码:");
        while(true) {
            // 接收用户输入的密码
            password = scan.nextLine();

            // 检测是否是-1（返回欢迎界面）
            if (password.equals("-1")) {
                helloView();
                return;
            }

            // 检验长度是否为6-18位
            if ( password.length() < 6 || password.length() > 18) {
                System.out.println("密码应该在6-18位之间，请重新输入");
                continue;
            }

            // 再次输入密码确认
            System.out.println("请再次确认密码:");
            String confirmPassword = scan.nextLine();
            // 密码校验
            if (!password.equals(confirmPassword)){
                System.out.println("密码不一致，请重新输入");
                continue;
            }

            // 注册账号
            try {
                GameService.register(username, password);
            } catch (IOException e) {
                throw new RuntimeException(e);
            }

            // 跳转到登录界面
            loginView();

            break;
        }

    }

    /*
        编号：3
        难度：简单
        负责人: Youndry
        功能: 登录界面
              while(true) {
                接收用户输入：
                    账号名(输入-1为返回欢迎界面)：
                判断用户输入是否为-1
                    是，返回欢迎界面 helloView(); return;
                    不是，判断账户是否存在在文件中(调用findPlayerService方法)
                        存在，break;
                        不存在，提示用户该账号不存在
            }
            while(true) {
                接收用户输入：
                    账号密码(输入-1为返回欢迎界面)：
                判断用户输入是否为-1
                    是，返回欢迎界面 helloView(); return;
                    不是，判断账户密码是否正确
                        正确,初始化用户player1对象(将player1指向返回的player对象);
                            跳转到mainView();return;
                        不正确，提示用户密码输入错误
            }

        参数: void
        返回值: void

     */
    public static void loginView(){
        // 界面内容
        System.out.println("==========登录==========");
        // username:接收用户输入的账号
        // password:接收用户输入的密码
        // user:接收用户登录的用户对象
        String username;
        String password;
        Player player;

        // 接收用户输入的账号
        System.out.println("请输入账号:");
        while(true) {
            // 接收用户输入的账号
            username = scan.nextLine();

            // 检测是否是-1（返回欢迎界面）
            if (username.equals("-1")) {
                helloView();
                return;
            }

            // 检验账号是否存在

       if ((player=GameService.findPlayerService(username))== null) {
                System.out.println("该账号不存在，请重新输入");
                continue;
            }

            break;
        }

        // 接收用户输入的密码
        System.out.println("请输入密码:");
        while(true) {
            // 接收用户输入的密码
            password = scan.nextLine();

            // 检测是否是-1（返回欢迎界面）
            if (password.equals("-1")) {
                helloView();
                return;
            }

            // 登录账号

            // 检验账号密码是否正确
            String confirmPassword = player.getPwd();
            if (!confirmPassword.equals(password)) {
                System.out.println("账号密码错误，请重新输入");
                continue;
            }

            //登录成功，初始化service层的player1对象
            GameService.setPlayer(player,1);

            // 进入主界面
            mainView();

            break;
        }

    }

    /*
        编号：4
        难度：简单
        负责人: Youndry
        功能: 主界面
              接收用户输入：1.人机对战 2.人人对战gameViewWithPlayer(0) 3.排行榜 4.商城 5.个人信息 6.游戏规则 7.退出游戏exit(0)
              跳转到相应界面
        参数: void
        返回值: void
     */
    public static void mainView(){
        System.out.println("==========主界面==========");
        System.out.println("请输入您的选择: 1.人机对战 2.人人对战 3.排行榜 4.商城 5.个人信息 6.游戏规则 7.退出游戏");

        // isValid:用来标记输入是否合法，合法则为true
        Boolean isValid = false;

        // choice:用来存储用户输入的选项
        int choice = 0;

        // 接收用户输入
        while (!isValid){
            // 检验用户输入的是否合法
            if (scan.hasNextInt()){
                choice = scan.nextInt();
                scan.nextLine();
            } else {
                System.out.println("输入有误，请输入一个整数");
                scan.nextLine();
                continue;
            }
            switch(choice) {
                case 1:
                    // 人机对战
                    isValid = true;
                    gameViewWithAI();
                    break;
                case 2:
                    // 人人对战
                    isValid = true;
                    gameViewWithPlayer(0);
                    break;
                case 3:
                    // 排行榜
                    isValid = true;
                    // 进入排行榜界面
                    RankingView();
                    break;
                case 4:
                    // 商城
                    isValid = true;
                    // 进入商城界面
                    ShopView();
                    break;
                case 5:
                    // 个人信息
                    isValid = true;
                    // 进入个人信息界面
                    UserInfoView();
                    break;
                case 6:
                    // 游戏规则
                    isValid = true;
                    // 进入游戏规则界面
                    GameRulesView();
                    break;
                case 7:
                    // 退出游戏
                    System.exit(0);
                    break;
                default:
                    System.out.println("输入有误，请在给出的选项中选择");
            }
        }

    }

    /*
        编号：5
        难度：困难
        负责人: 听
        功能: 人机游戏界面
            接收用户输入的难度选项 1.简单(1) 2.一般(3) 3.困难
                判断如果是3接收用户下注金币数(5-10)
            提示用户本局难度，下注金币数为多少 1.简单(1) 2.一般(3) 3.困难(下注数)
            展示用户所拥有的所有棋子id和对应颜色(getAllqizi方法)
            接收用户选择棋子的id
            初始化游戏数据(调用initWithAI())
            while(true) {
                 打印游戏界面(调用函数gameView_ShowMap())
                 判断玩家还是ai在下棋
                    玩家
                        接收玩家坐标输入
                        判断用户输入是否为(20,20)
                         (是 认输调用人机胜利界面 结束当前界面)
                    ai
                        ai下棋 返回下棋坐标
                 落子(调用落子函数playerMove())
                    (如果落子失败 重新开始循环)
                 判断游戏是否胜利(调用胜利判断函数isWin())
                    (如果游戏胜利 调用人机胜利界面函数 然后结束当前界面)
                 切换玩家(修改flag值)
            }

        参数: void
        返回值: void
    */
    public static void gameViewWithAI(){
        Scanner scanner = new Scanner(System.in);
        // 输出欢迎界面
        System.out.println("=======================================");
        System.out.println("|         欢迎进入人机对战游戏         |");
        System.out.println("=======================================");
        System.out.println("|   请选择游戏难度：                  |");
        System.out.println("|   1. 简单（Easy）                  |");
        System.out.println("|   2. 一般（Normal）                |");
        System.out.println("|   3. 困难（Hard）                  |");
        System.out.println("=======================================");

        // 接收用户输入
        System.out.print("请输入难度选项（1-3）：");
        int difficulty;
        while(true){
            difficulty = scanner.nextInt();
            if (difficulty>=1&&difficulty<=3){
                break;
            }
            System.out.println("❗无效输入,请重新输入");
        }
        int bet = 0; // 下注金币数
        if(difficulty==1){
            bet=1;
        }else if(difficulty==2){
            bet=3;
        }else if (difficulty == 3) {
            System.out.println("=======================================");
            System.out.println("|       您选择了困难模式！            |");
            System.out.println("|   请下注金币数（范围：5-10）：      |");
            System.out.println("=======================================");
            while (true) {
                System.out.print("请输入下注金额：");
                bet = scanner.nextInt();
                if (bet >= 5 && bet <= 10) {
                    break;
                } else {
                    System.out.println("❗下注金额无效，请输入5到10之间的数字！");
                }
            }
        }
        // 提示用户选择结果
        System.out.println("=======================================");
        System.out.println("|          游戏难度设置成功！          |");
        switch (difficulty) {
            case 1:
                System.out.println("| 您选择的难度：简单（Easy）          |");
                System.out.println("| 您的下注金币数：" + bet + "               |");
                break;
            case 2:
                System.out.println("| 您选择的难度：一般（Normal）        |");
                System.out.println("| 您的下注金币数：" + bet + "               |");
                break;
            case 3:
                System.out.println("| 您选择的难度：困难（Hard）          |");
                System.out.println("| 您的下注金币数：" + bet + "               |");
                break;
            default:
                System.out.println("| ❗无效的选择，请重新运行程序！        |");
                return;
        }
        System.out.println("=======================================");
        System.out.println("|       准备开始游戏吧！              |");
        System.out.println("=======================================");
        System.out.println();

        // 展示用户棋子
        System.out.println("|       您拥有的棋子如下：            |");
        Map<Integer, String> qizi = GameService.getAllqizi(1);
        for (Map.Entry<Integer, String> entry : qizi.entrySet()) {
            System.out.println("|   棋子ID：" + entry.getKey() + "，颜色：" + entry.getValue() + "        |");
        }
        System.out.println("=======================================");

        // 接收用户选择的棋子ID
        int selectedId;
        while (true) {
            System.out.print("请输入您选择的棋子ID：");
            selectedId = scanner.nextInt();
            if (qizi.containsKey(selectedId)) {
                System.out.println("您选择的棋子ID为：" + selectedId + "，颜色：" + qizi.get(selectedId));
                break;
            } else {
                System.out.println("❗无效的棋子ID，请重新输入！");
            }
        }

        System.out.println("=======================================");
        System.out.println("|       准备开始游戏吧！              |");
        System.out.println("=======================================");
        GameService.initWithAI(selectedId,difficulty);
        int x,y,num;
        while(true){
            GameView.gameView_ShowMap();
            if(GameService.whoTurn()==0){
                while(true){
                    System.out.println("💫请输入接下来要下的坐标(格式：x y):");
                    x=scanner.nextInt();
                    y=scanner.nextInt();
                    if(x==20&&y==20){
                        winViewWithAI(2,bet);
                        return;
                    }
                    if(x<0||x>=15||y<0||y>=15){
                        System.out.println("❗输入不合法,请重新输入");
                    }else if(GameService.playerMove(x,y)==0){
                        System.out.println("❗该位置已有棋子，请重新输入");
                    }else {
                        break;
                    }
                }

                if(GameService.isWin(x,y)==1){
                    winViewWithAI(1,bet);
                    break;
                }
            }else{

                num=GameService.getAi().run(GameService.getMap());
                x=GameService.getAi().getX();
                y=GameService.getAi().getY();
                GameService.playerMove(x, y); //ai下的棋一定是合法的
                if(GameService.isWin(x,y)==2){
                    winViewWithAI(2,bet);
                    break;
                }
            }
            GameService.changeSide();


        }
    }

    /*
        编号：6
        难度：简单
        负责人: 听
        功能: 根据n的值 打印游戏胜利界面
             输出胜利对象和金币流水 更改player1的对应属性(调用changePlayerService方法)
             用户可以按任意键回到主菜单
        参数: n 传入1代表用户赢 传入2代表ai赢
             money代表下注金额
        返回值: void
    */

    public static void winViewWithAI(int n,int money){
        GameService.changePlayerService(n,money);
        gameView_ShowMap();
        if(n==1){
            System.out.println("🎉🎉 恭喜你获得游戏胜利 🎉🎉 ");
            System.out.println("你得到的金币数量"+money);
            System.out.println("剩余金币数\uD83D\uDCB0:"+GameService.getPlayer1().getMoney());
        }else{
            System.out.println("🤖 你输了,菜就多练 🤖     ");
            System.out.println("你失去的金币数量"+money);
            System.out.println("剩余金币数\uD83D\uDCB0:"+GameService.getPlayer1().getMoney());
        }
        System.out.println("输入回车键返回主菜单");
        scan.nextLine();
        mainView();

    }

    /*
        编号：7
        难度：简单
        负责人: 听
        功能: 根据map数组 打印游戏棋盘
            map数组是棋子id，需要调用service层的findQiziService方法得到棋子对象找到对应样式再打印
            提示用户输入20 20认输 输入21 21悔棋(人机模式没有悔棋)
        参数: void
        返回值: void
    */
    public static void gameView_ShowMap(){
        int[][] map = GameService.getMap();
        System.out.println("    \u20020  1   2\u2009 3  \u20044 \u20045  \u20046  7  \u20028  9  10 11 \u200212 13 \u200214");
        // 输出棋盘内容，每行前面加上行号
        for (int i = 0; i < 15; i++) {
            System.out.print(String.format("%2d ", i)); // 打印行号
            for (int j = 0; j < 15; j++) {
                int cell = map[i][j];
                // 打印棋盘位置：如果是空格则打印空白，否则打印棋子
                if (cell ==0) {
                    System.out.print(String.format("%2s","⬜"));
                } else{
                    String style=GameService.findQiziService(cell).getStyle();
                    if(EmojiUtils.isEmoji(style)){
                        System.out.print(String.format("%3s",style));
                    }else{
                        System.out.print(String.format("%2s", style));
                    }
                }
            }
            System.out.println();
        }
        System.out.println("认输(20 20) 悔棋(21 21)[人机模式无此功能]");
    }



    /*
        编号：8
        难度：困难
        负责人: 灯火阑珊
        功能: 人人游戏界面
        判断用户2是否为空
           是，提示用户2登录
                接受用户2的账号名和密码
                判断用户2是否合法(loginIsLegal)
                    不合法，继续接收用户2的账号名和密码
                初始化用户player2对象(findPlayerService将player2指向返回的player对象);
           不是，选棋子
                展示用户1所有的棋子(getAllqizi(1))
                接收用户1选择的棋子id1
                展示用户2所有的棋子(getAllqizi(2))
                接收用户2选择的棋子id2
                    如果选了跟用户1一样的 继续接收用户2选择的棋子id
                初始化游戏数据(调用initWithPlayer)
            提示谁是先手(first判断)
            while(true) {
                 打印游戏界面(调用函数gameView_ShowMap())
                  接收玩家坐标输入
                      判断用户输入是否为(20,20)
                         (是 认输调用人人胜利界面 结束当前界面)
                      判断用户输入是否为(21,21)
                         是 跳转到悔棋界面 展示棋盘，继续接收用户输入 continue
                 落子(调用落子函数playerMove())
                    (如果落子失败 重新开始循环)
                 判断游戏是否胜利(调用胜利判断函数isWin())
                    (如果游戏胜利 调用人人胜利界面函数 然后结束当前界面)
                 切换玩家(修改flag值)
            }
        参数: first 此局谁先手 0用户1先手 1用户2先手

        返回值: void
    */

    public static void gameViewWithPlayer(int first){
        // 判断用户2是否为空
        while (GameService.getPlayer2()== null) {
            System.out.println("=======================================");
            System.out.println("| 请确认用户二已经登陆!              |");
            System.out.println("=======================================");
            System.out.print("输入用户二的账号名: ");
            String name = scan.nextLine();
            System.out.println("输入用户二的密码: ");
            String pwd = scan.nextLine();
            if (GameService.loginIsLegal(name, pwd)) {
                // 找到玩家并将其设置为 player2
                Player player = GameService.findPlayerService(name);  // 获取玩家对象
                GameService.setPlayer(player, 2);  // 设置 player2 为登录的玩家
            } else {
                // 获取用户1的账号名
                String player1Name = GameService.getPlayer1().getName();
                if (name.equals(player1Name)) {
                    System.out.println("用户二不能与用户一相同，请重新登录！");
                    continue;  // 如果用户2和用户1相同，则重新输入
                }else {
                    System.out.println("账号或密码不对，请再次输入！");
                }
            }
        }

        // 展示用户1的所有棋子
        System.out.println("=======================================");
        System.out.println("| 用户一拥有的棋子如下：              |");
        System.out.println("=======================================");
        Map<Integer, String> qizi = GameService.getAllqizi(1);
        for (Map.Entry<Integer, String> entry : qizi.entrySet()) {
            System.out.println("|   棋子ID：" + entry.getKey() + "，颜色：" + entry.getValue() + "        |");
        }
        System.out.println("=======================================");
        System.out.println("| 请用户一选择棋子:                  |");
        System.out.println("=======================================");
        int id1 = scan.nextInt();
        // 确保用户1输入的棋子ID是有效的
        while (!qizi.containsKey(id1)) {
            System.out.println("无效的棋子ID，请重新选择！");
            id1 = scan.nextInt();
        }


        // 展示用户2的所有棋子
        System.out.println("=======================================");
        System.out.println("| 用户二拥有的棋子如下：              |");
        System.out.println("=======================================");
        qizi = GameService.getAllqizi(2);
        for (Map.Entry<Integer, String>  entry : qizi.entrySet()) {
            System.out.println("|   棋子ID：" + entry.getKey() + "，颜色：" + entry.getValue() + "        |");
        }
        int id2;
        // 确保用户2选择的棋子与用户1不同
        while (true) {
            System.out.println("=======================================");
            System.out.println("| 请用户二选择棋子:                  |");
            System.out.println("=======================================");
            id2 = scan.nextInt();
            // 确保用户2输入的棋子ID是有效的
            while (!qizi.containsKey(id2)) {
                System.out.println("无效的棋子ID，请重新选择！");
                id2 = scan.nextInt();
            }
            //判断输入合法
            if (id1 != id2) {
                break;
            }
            System.out.println("不能选择与用户一相同的棋子，请重新选择");
        }
        // 游戏流程
        GameService.initWithPlayer(id1, id2, first);
        while (true) {
            gameView_ShowMap();

            // 当前玩家信息
            System.out.println("=======================================");
            System.out.println("| 玩家" + ((GameService.whoTurn() == 0) ? "一" : "二") + "的回合，请输入坐标 (格式：x y)： |");
            System.out.println("=======================================");

            // 接收玩家输入的坐标
            int x = scan.nextInt();
            int y = scan.nextInt();
            if (x == 20 && y == 20) {
                // 玩家认输
                System.out.println("=======================================");
                System.out.println("| 玩家" + ((GameService.whoTurn() == 0) ? "一" : "二") + "认输！ |");
                System.out.println("=======================================");
                winViewWithPlayer(GameService.whoTurn() == 0 ? 2 : 1, first);
                break;
            }

            // 判断是否悔棋
            if (x == 21 && y == 21) {
                System.out.println("=======================================");
                System.out.println("| 进入悔棋模式...                     |");
                System.out.println("=======================================");
                regretView(); // 调用悔棋逻辑
                continue;
            }

            // 执行玩家落子
            if (GameService.playerMove(x, y) == 0) {
                System.out.println("=======================================");
                System.out.println("| 落子失败，请重新输入！             |");
                System.out.println("=======================================");
                continue;
            }

            // 判断是否胜利
            if (GameService.isWin(x, y) != 0) {
                System.out.println("=======================================");
                System.out.println("| 游戏结束！玩家" + ((GameService.whoTurn() == 0) ? "一" : "二") + "获胜！ |");
                System.out.println("=======================================");
                winViewWithPlayer(GameService.whoTurn()%2==0?1:2, first);
                break;
            }

            // 切换玩家
            GameService.changeSide();
        }
    }

    /*
        编号：9
        难度：简单
        负责人: 灯火阑珊
        功能: 根据n的值 打印游戏胜利界面
             输出胜利对象和金币流水 更改player的对应属性(调用changePlayerService(n,6)方法 默认金币为6)
             接收用户输入 1.返回主界面 同时销毁玩家22.再来一局gameViewWithPlayer(first==0?1:0) 切换先手
        参数: n 传入1代表用户1赢 传入2代表用户2赢
             first为这局是谁先手
        返回值: void
    */
    public static void winViewWithPlayer(int n,int first){
        gameView_ShowMap();
        int money = 6; // 默认金币奖励
        System.out.println("=======================================");
        System.out.println("| 恭喜玩家" + n + "获胜！获得金币奖励：" + money + " |");
        System.out.println("=======================================");


        // 更新属性
        GameService.changePlayerService(n, money);

        // 用户选择
        System.out.println("=======================================");
        System.out.println("| 1. 返回主界面                      |");
        System.out.println("| 2. 再来一局                        |");
        System.out.println("=======================================");
        int choice = scan.nextInt();

        if (choice == 1) {
            GameService.setPlayer(null,2);
            GameView.mainView();
        } else if (choice == 2) {
            GameView.gameViewWithPlayer(first==0?1:0);
        }
    }

    /*
        编号：10
        难度：一般
        负责人：灯火阑珊
        功能：
            判断此用户下过棋没有
                没有，提示：还没有下过棋哦 return
            打印当前悔棋要花费金币数以及该玩家有的钱数（当前玩家用flag来判断）
            (悔棋消耗金币；金币数量为当前悔棋次数的平方)
            判断是否可以支付起
                不可以，提示金钱数不够 return
            再次询问：将XXX金币给另一玩家，确定悔棋吗
                不确定,return
            询问另一玩家：对方给你XX金币，是否同意悔棋
                不同意，提示玩家对方不同意，return
            还原棋盘(撤销两步) 加给钱收钱-->(regret方法)
        参数：void
        返回值：void
     */
    public static void regretView(){
        // 判断此用户是否下过棋
        if (!GameService.havePlay()) {
            System.out.println("=======================================");
            System.out.println("| 还没有下过棋哦！                   |");
            System.out.println("=======================================");
            return;
        }

        // 通过 whoTurn 判断当前玩家
        int currentPlayer = GameService.whoTurn()%2==0?1:2;  // whoTurn() == 0 -> 玩家1，whoTurn == 1 -> 玩家2
        Player[] players = new Player[3];
        players[1] = GameService.getPlayer1();
        players[2] = GameService.getPlayer2();
        // 获取当前悔棋的费用
        int num = players[currentPlayer].getRegret();
        num += 1;
        int regretCost = num * num;
        int currentPlayerMoney = players[currentPlayer].getMoney();  // 获取当前玩家的金币数量

        // 打印悔棋费用和当前金币数量
        System.out.println("=======================================");
        System.out.println("| 当前悔棋费用: " + regretCost + "金币    |");
        System.out.println("| 玩家" + currentPlayer + "金币: " + currentPlayerMoney + " |");
        System.out.println("=======================================");

        // 判断当前玩家是否有足够的金币
        if (currentPlayerMoney < regretCost) {
            System.out.println("=======================================");
            System.out.println("| 玩家" + currentPlayer + "金币不足，无法悔棋！ |");
            System.out.println("=======================================");
            return;
        }

        // 清除缓冲区中的换行符，避免跳过输入
        scan.nextLine();

        // 确认是否将金币支付给对方
        System.out.println("=======================================");
        System.out.println("| 玩家" + currentPlayer + "确定要将 " + regretCost + " 金币给对方，进行悔棋吗？ (y/n) |");
        System.out.println("=======================================");
        String confirm = scan.nextLine();

        if (!confirm.equals("y")) {
            System.out.println("=======================================");
            System.out.println("| 玩家" + currentPlayer + "取消了悔棋操作！   |");
            System.out.println("=======================================");
            return;
        }

        // 询问另一玩家是否同意悔棋
        int otherPlayer = (currentPlayer == 1) ? 2 : 1;  // 获取对方玩家
        System.out.println("=======================================");
        System.out.println("| 玩家" + otherPlayer + "，对方给您 " + regretCost + " 金币，是否同意悔棋？ (y/n) |");
        System.out.println("=======================================");
        String consent = scan.nextLine();
        if (!consent.equalsIgnoreCase("y")) {
            System.out.println("=======================================");
            System.out.println("| 玩家" + otherPlayer + "不同意悔棋！         |");
            System.out.println("=======================================");
            return;
        }

        // 执行悔棋操作（撤销两步）
        GameService.regret(regretCost); // 调用悔棋方法，撤销两步棋
        System.out.println("=======================================");
        System.out.println("| 悔棋成功！                         |");
        System.out.println("=======================================");
}

    /*
   编号：11
   难度：一般
   负责人：今天
   功能：
   *商城界面
   * 调用service层方法ShopSortService得到所有棋子，进行展示
      当前用户(player1)已经拥有的要标注已拥有
   * 提示用户选择购买皮肤ID （输入合法判断）
   * 判断是否输入为-1，是-1返回主界面，结束当前界面
   * 不是就判断是否可以购买，判断条件：是否拥有，金币够不够
   * 没有且金币够，则可以购买
   * 调用service层方法ShopService，继续商城界面，无论购买成功还是失败
   *参数：void
    返回值;void*/
    public static void ShopView(){
        while (true) {
            //当前用户(player1)已经拥有的要标注已拥有
            List<Chess> chess = GameService.ShopSortService();
            for(Chess i:chess){
                if(GameService.getPlayer1().getTotalChess().contains(i.getId())){
                    System.out.println("| " + i.getId() + " | " + i.getStyle() + " | 已拥有 | " + i.getPrice() + " |");
                }else{
                    System.out.println("| " + i.getId() + " | " + i.getStyle() + " | " + i.getPrice() + " |");
                }
            }

            //提示用户选择购买皮肤ID （输入合法判断）
            System.out.println("请输入皮肤ID进行购买(-1返回主界面):");
            int id = scan.nextInt();
            if(id==-1){
                mainView();
                break;
            }
            //判断输入是否合法
            if (id<1||id>chess.size()){
                System.out.println("输入不合法");
                System.out.println();
                continue;
            }

            //是否拥有，金币够不够
            if(GameService.getPlayer1().getTotalChess().contains(id)){
                System.out.println("您已拥有");
                System.out.println();
            }else{
                if( chess.get(id-1).getPrice()>= GameService.getPlayer1().getMoney()){
                    System.out.println("钱都没有，真穷");
                    System.out.println();
                }else {
                    GameService.ShopService(id);
                }
            }
        }
        
    }

    /*
    编号：12
    难度：简单
    负责人：123
    功能：
       当前用户(GameService.getPlayer1)的信息展示
       通过GameService.getPlayer1得到player1对象
       展示其信息(regret chess不用展示) 格式要弄成表格
       其中拥有的棋子id要通过findQiziService得到其样式进行展示
    * 输入0返回主界面*/
    public static void UserInfoView(){
        System.out.println("==========个人信息界面==========");
        Player player1 = GameService.getPlayer1();
        System.out.println("用户id：\t\t\t" + player1.getId());
        System.out.println("用户名称：\t\t" + player1.getName());
        System.out.println("用户密码：\t\t" + player1.getPwd());
        System.out.println("金币数量：\t\t" + player1.getMoney());
        List<Integer> totalChess = player1.getTotalChess();
        System.out.print("拥有的棋子有：\t\t" + "[  ");
        for (Integer num : totalChess) {
            Chess qizi = QiziDao.findQizi(num);
            System.out.print(qizi.getId() +"、"+ qizi.getStyle() + "  ");
        }
        System.out.println(" ]");
        System.out.println("人机对战赢的次数：\t" + player1.getWithAIWin());
        System.out.println("人人对战赢的次数：\t" + player1.getWithPlayerWin());
        System.out.println("人机对战输的次数：\t" + player1.getWithAILose());
        System.out.println("人人对战输的次数：\t" + player1.getWithPlayerLose());
        System.out.println("===============================");

        while (true) {
            System.out.println("请输入0返回主菜单：");
            if (scan.nextInt() == 0){
                mainView();
            }else {
                System.out.println("输入不合法，请重新输入！");
            }
        }
    }

    /*
       编号：13
       难度：一般
       负责人:Youndry
       功能: 排行主界面
             开始先默认按金币进行排行,调用getMoneyList进行展示
             展示id,username,money,withPlayerWin
             接收用户输入：1.按金币数进行排行(调用getMoneyList),2.按人人对战胜利数排行(调用getWithPlayerWinlist),3.退出到mainView()界面
             跳转到相应界面
       参数: void
       返回值: void
        */
    public static void RankingView() {
        // 获取排行榜Players数据
        List<Player> players_sortByMoney = service.GameService.getMoneyList();
        // 如果为空赋值空表
        if (players_sortByMoney == null) {
            players_sortByMoney = new ArrayList<>();
        }
        List<Player> players_sortByWin = service.GameService.getWithPlayerWinlist();
        // 如果为空赋值空表
        if (players_sortByWin == null) {
            players_sortByWin = new ArrayList<>();
        }

        // 打印排行榜（默认按照金币数排行）
        // 这里加了个名次
        System.out.println("==========富翁榜==========");
        System.out.printf("%-5s%-15s%-10s%-15s%-5s%n", "id", "username", "money", "withPlayerWin", "rank");
        int n = 0;
        for (Player player : players_sortByMoney) {
            System.out.printf("%-5d%-15s%-10d%-15d%-5d%n", n++, player.getName(), player.getMoney(), player.getWithPlayerWin(), n);
        }

        // 接收用户输入，1.按金币数进行排行(调用getMoneyList),2.按人人对战胜利数排行(调用getWithPlayerWinlist),3.退出到mainView()界面
        System.out.println("1.富翁榜 2.分数榜 3.返回");
        // isValid:用来标记输入是否合法，合法则为true
        Boolean isValid = false;

        // choice:用来存储用户输入的选项
        int choice = 0;

        while (!isValid) {
            // 检验用户输入的是否合法
            if (scan.hasNextInt()) {
                choice = scan.nextInt();
                scan.nextLine();
            } else {
                System.out.println("输入有误，请输入一个整数");
                scan.nextLine();
                continue;
            }
            switch (choice) {

                case 1: // 1.按金币数进行排行(调用getMoneyList)
                    System.out.println("==========富翁榜==========");
                    System.out.printf("%-5s%-15s%-10s%-15s%-5s%n", "id", "username", "money", "withPlayerWin", "rank");
                    int n1 = 0;
                    for (Player player : players_sortByMoney) {
                        System.out.printf("%-5d%-15s%-10d%-15d%-5d%n", n1++, player.getName(), player.getMoney(), player.getWithPlayerWin(), n1);
                    }
                    break;

                case 2: // 2.按人人对战胜利数排行(调用getWithPlayerWinlist)
                    System.out.println("==========分数榜==========");
                    System.out.printf("%-5s%-15s%-10s%-15s%-5s%n", "id", "username", "money", "withPlayerWin", "rank");
                    int n2 = 0;
                    for (Player player : players_sortByMoney) {
                        System.out.printf("%-5d%-15s%-10d%-15d%-5d%n", n2++, player.getName(), player.getMoney(), player.getWithPlayerWin(), n2);
                    }
                    break;
                case 3: // 3.退出到mainView()界面
                    isValid = true;
                    mainView();
                    break;

                default:
                    System.out.println("输入有误，请在给出的选项中选择");
            }
        }
    }

    /*
    负责人：李季岭

    功能：
    * 显示游戏规则
    * 如悔棋规则、胜利规则、介绍游戏流程等
    * 输入0返回主界面
    参数：void
    返回值：void
    */
    public static void GameRulesView(){
        System.out.println("=======================轰天裂地五子棋游戏规则=======================");
        System.out.println("一.胜利了规则：双方轮流通过输入xy在棋盘落一颗子，棋盘上哪一方先五颗子在同一直线上连续连成直线，则为胜利");
        System.out.println("二.奖罚机制：\n" +
                "1.人机对战简单模式获胜将获得1金币，失败会扣除1金币\n" +
                "2.人机对战一般模式获胜将获得3金币，失败会扣除3金币\n" +
                "3.人机对战困难模式将采用下注形式，玩家在5-10金币数内选择下注金额，胜利将获得与下注金额相等的金币，失败会失去下注金额的数量\n" +
                "4.人人对战获胜将获得6金币" );
        System.out.println("三，悔棋规则：在人人对战模式中在玩家当前回合输入坐标(21,21)将会询问你是否悔棋，悔棋你将会给与你的对手悔棋次数的平方数量的金\n币个数,同时" +
                "会询问你的对手是否接受你的悔棋，在对手同意过后将会回到玩家上一次直接落子前；人机对战则无悔棋功能");
        System.out.println("四，认输规则：在玩家输入坐标回合输入(20，20)玩家会直接认输,询问是否重新开始或者退回主菜单");
        System.out.println("五.人人对战规则：选择人人对战后还需要输入玩家二的账号密码进行pk，各玩家可以选择自己喜欢的皮肤开始后进行对战" +
                "第一局将会是玩家\n一为先手，如果重开的话第二局是玩家二为先手，后续将一直轮流先手");
        System.out.println("六.人机对战规则：玩家会先选择AI难度有简单、一般、困难，然后选择棋子皮肤后开始对战,玩家将为先手落子,AI将会随机棋子皮肤");
        System.out.println("七.在控制台里面输入-1，返回上一级界面");
        System.out.println();
        while (true) {
            System.out.println("输入-1返回主界面");
            String next = scan.next();
            if(next.equals("-1")) {
                mainView();
                break;
            } else {
                System.out.println("输入有误...");
            }
        }

    }





}
